package com.sduept.nwld.wave.util;

import lombok.extern.slf4j.Slf4j;

import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Slf4j
public class NameTool {
	
	/**
	 * <p>Description:比较准确的放到后面,获取高压侧绕组匹配关键字,#4主变高压侧套管电流B相,#1主变变高套管电流，</p>
	 * "高电压","高压","高套管"
	 * @author zjx
	 * @date 2017年7月3日
	 * @return
	 */
	public static String[] getHighWindingKeys(){
		String []matchStrings = {"高"};
		return matchStrings;
	}
	
	/**
	 * <p>Description:获取中压侧绕组匹配关键字,#4主变中压侧电流A相,#1主变变中开关电流,,#1主变变中套管电流</p>
	 * @author zjx
	 * @date 2017年7月3日
	 * @return
	 */
	public static String[] getMiddleWindingKeys(){
		String []matchStrings = {"中"};
		return matchStrings;
	}
	/**
	 * <p>Description:获取低压侧绕组匹配关键字,#4主变低压侧电流A相,#1主变变低套管电流,#1主变变低开关电流</p>
	 * @author zjx
	 * @date 2017年7月3日
	 * @return
	 */
	public static String[] getLowWindingKeys(){
		String []matchString = {"低"};
		return matchString;
	}
	
	/**
	 * <p>Description:获取公共绕组匹配关键字,#1主变中性点套管电流</p>
	 * @author zjx
	 * @date 2017年7月3日
	 * @return
	 */
	public static String[] getCommonWindingKeys(){
		String []matchStrings = {"中性点","公共"};
		return matchStrings;
	}

	/**
	 * <p>Description:是不是高压侧</p>
	 * @author zjx
	 * @date 2017年7月3日
	 * @param name
	 * @return
	 */
	public static boolean isHighWinding(String name){
		return isMatch(name, getHighWindingKeys());
	}
	
	public static boolean isMiddleWinding(String name){
		return isMatch(name, getMiddleWindingKeys());
	}
	
	public static boolean isLowWinding(String name){
		return isMatch(name, getLowWindingKeys());
	}
	
	public static boolean isCommonWinding(String name){
		return isMatch(name, getCommonWindingKeys());
	}
	
	
	/**
	 * <p>Description:name 与 keyWords 匹配返回 true,不匹配返回false</p>
	 * @author zjx
	 * @date 2017年7月3日
	 * @param name
	 * @param keyWords
	 * @return
	 */
	public static boolean isMatch(String name,String keyWords[]){
		Pattern pattern = null;
		Matcher matcher = null;
		for(String key:keyWords){
			pattern = Pattern.compile(key);
			matcher = pattern.matcher(name);
			if(matcher.find()){
				return true;
			}
		}
		return false;
	}
	
	/**
	 * <p>Description:获取匹配的名字，首先筛掉不匹配的，然后进行名称替换，最后进行匹配（返回匹配的group(1)）</p>
	 * @author zjx
	 * @date 2017年7月4日
	 * @param name
	 * @param noMatchStrings,允许为null
	 * @param replaceStrings,允许为null
	 * @param matchStrings,允许为null
	 * @return
	 */
	public static String getMatchName(String name,String noMatchStrings[],String replaceStrings[],String matchStrings[]){
		Pattern pattern = null;
		Matcher matcher = null;
		String copyOfName = name;
		
		//过滤不符合条件的
		if(noMatchStrings!=null&&noMatchStrings.length>0){
			
			for(String noMatchString:noMatchStrings){
				pattern = Pattern.compile(noMatchString);
				matcher = pattern.matcher(copyOfName);
				if(matcher.find()){
					return copyOfName;
				}
			}
		}
		
		//字符串替换
		if(replaceStrings!=null&&replaceStrings.length>0){
			for(String replaceString:replaceStrings){
				String splitStrs[] = replaceString.split(",");
				copyOfName = copyOfName.replaceAll(splitStrs[0], splitStrs[1]);
			}
		}
	
		//查找母线编号数字
		if(matchStrings!=null&&matchStrings.length>0){
			for(String matchString:matchStrings){
				pattern = Pattern.compile(matchString);
				matcher = pattern.matcher(copyOfName);
				if(matcher.find()){
					return matcher.group(1);
				}
			}
		}
		return name;
	}
	
	
	
	
	/**
	 * <p>Description:获取 准确用于 比较的 母线名</p>
	 * @author zjx
	 * @date 2017年7月4日
	 * @param busName
	 * @return
	 */
	public static String getBusNameOfNw(String busName){
		String replaceStrings[] = {"Ⅵ母|Ⅵ段|VI母|VI段,6母","Ⅳ母|Ⅳ段|IV母|IV段|四母,4母","Ⅴ母|V段|五母,5母",
				"Ⅲ母|Ⅲ段|III母|III段|三母,3母","Ⅱ母|Ⅱ段|II母|II段|B母|二母,2母","Ⅰ母|Ⅰ段|I母|I段|A母|一母,1母"
				};
		String noMatchStrings[] = {};
		String matchStrings[] = {"(\\d+)(M|母|BM|AM|机端母线|发电机机端|过渡母线)","(?<=KV|kV|kv|Kv)#(\\d+)"};
		return getMatchName(busName, noMatchStrings, replaceStrings, matchStrings);
	}
	
	public static float getFloatVoltageOfNw(String name){
		String volStr = getVoltageOfNw(name);
		if(!volStr.equals(name)){
			return Float.parseFloat(volStr);
		}else{
			return 0;
		}
	}
	
	/**
	 * <p>Description:按照指定分段，转换出标准电压等级</p>
	 * @author zjx
	 * @date 2017年7月1日
	 * @param vol
	 * @return
	 */
	public static int getIntVoltageOfNw(float vol){
		if(vol>=500){
			return 500;
		}else if(vol>=220){
			return 220;
		}else if(vol>=110){
			return 110;
		}else if(vol>=30){
			return 35;
		}else{
			return 10;
		}
	}
	
	
	/**
	 * <p>Description:可能为 浮点</p>
	 * @author zjx
	 * @date 2017年6月30日
	 * @param name
	 * @return
	 */
	public static String getVoltageOfNw(String name){
		if(name.indexOf("220")!=-1){
			return "220";
		}else if(name.indexOf("500")!=-1){
			return "500";
		}else if(name.indexOf("110")!=-1){
			return "110";
		}else if(name.indexOf("35")!=-1){
			return "35";
		}else if(name.indexOf("13.8")!=-1){
			return "13.8";
		}else{
			Pattern voltStr = Pattern.compile("(\\d+)(?=(kv|KV|kV|Kv))");
			Matcher matcher = voltStr.matcher(name);
			if(matcher.find()){
				return matcher.group(1);
			}
			return name;
		}
	}
	
	/**
	 * <p>Description: KG2030,x430,5563,110kV李木Ⅰ线开关1159，5031断路器，5032开关,11-201A开关电流Ic,2002 A相分位,302 分位，302合位</p>
	 * @author zjx
	 * @date 2017年7月4日
	 * @param breakerName
	 * @return
	 */
	public static String getBreakerNameOfNw2(String breakerName){
		String replaceStrings[] = {};
		String noMatchStrings[] = {};
		String matchStrings[] = {"(\\d+[a-zA-Z]*)(断路器|开关)","(?<=KG|x|开关)(\\d+[a-zA-Z]*)","^(\\d+)$","(\\d+) *[A相|B相|C相|分位|合位]"};
		return getMatchName(breakerName, noMatchStrings, replaceStrings, matchStrings);
	}
	public static final String regex_feature_breaker = "\\d{4}|\\d{3}";
	public static final String regex_feature_busbar = "\\d{1}";
	public static final Pattern BREAKER_NAME_PATTERN = Pattern.compile(regex_feature_breaker);
	public static final Pattern BUSBAR_NAME_PATTERN = Pattern.compile(regex_feature_busbar);
	public static String getBreakerNameOfNw(String name){
		name = convertString(name,break_regex);
		Matcher m = BREAKER_NAME_PATTERN.matcher(name);
		if (m.find()) {
			return m.group(0);
		}
		
		int pos = name.indexOf("断路器");
		if(pos > -1){
			name = name.substring(0, pos);
		} else {
			pos = name.indexOf("开关");
			if(pos > -1){
				name = name.substring(0,  pos);
			} 
		}
		if(pos > -1)
			name = convertString(name,break_regex);
		return name;
	}
	public static String[][] break_regex = new String[][]{
		{"\\s*", ""},
		{"//|[0-9]+[-,_]", ""},
		{"//|[0-9]+[k,K]+[V,v]", ""}
	};
	/**
	 * <p>Description:获取电抗器关联一次设备</p>
	 * @author zjx
	 * @date 2017年6月26日
	 * @param reatorName
	 * @return
	 */
	public static String getReactorNameOfNw(String reatorName){
		Pattern pattern = Pattern.compile("(\\S+)(\\s)*(高抗|并联电抗器|耦合电抗器|串抗|电抗|主电抗|小电抗)");
		Matcher matcher = pattern.matcher(reatorName);
		if(matcher.find()){
			return matcher.group(1);
		}else{
			return reatorName;
		}
	}
	
	/**
	 * <p>Description:进行一次设备名格式化，将非罗马数字转换为罗马数字</p>
	 * @author zjx
	 * @date 2017年6月26日
	 * @param deviceOneName
	 * @return
	 */
	public static String toRomanNum(String deviceOneName){
		return deviceOneName.replaceAll("(四|IV|4)", "Ⅳ")
				.replaceAll("(五|V|5)", "Ⅴ")
				.replaceAll("(三|III|3)", "Ⅲ")
		        .replaceAll("(二|II|2)", "Ⅱ")
		        .replaceAll("(一|I|1)", "Ⅰ");
	}
	
	
	/**
	 * <p>Description:获取变压器名称中的数字，</p>
	 * <p>#3L联变，#3变压器，#3主变，1#主变,＃1站用变,1TM,#1联变,#4变压器,#2降压变,#6换流变,#1启备主变,#1两卷变,#3两卷调压变压器</p>
	 * <p>换流变-云南侧柘林4号变,#2L联变,C3B站用变,1T站用变,500kV#1站用变,#1高备变</p>
	 * <p>2B</p>
	 * <p>#2B，#S1B,#P1B,#A1B,#C1B</p>
	 * <p>STATCOM专用变#8</p>
	 * @author zjx
	 * @date 2017年6月26日
	 * @param transName
	 * @return
	 */
	public static String getTransformerNameOfNw(String transName){
		String noMatchStrings[] = {};
		String strings[] = {"(\\d+)(三卷变压器|#主变|TM|号主变|L联变|主变|号变|B站用变|T站用变|变压器|站用变|联变|降压变|换流变|启备主变|两卷变|两卷调压变压器)","^(\\d+)B","(?<=#|#P|#C|#A|#S)(\\d+)B","(?<=站用变#)(\\d+)"};
		for(int i=0;i<noMatchStrings.length;i++){
			Pattern pattern = Pattern.compile(noMatchStrings[i]);
			Matcher matcher = pattern.matcher(transName);
			if(matcher.find()){
				return transName;
			}
		}
		for(int i=0;i<strings.length;i++){
			Pattern pattern = Pattern.compile(strings[i]);
			Matcher matcher = pattern.matcher(transName);
			if(matcher.find()){
				return matcher.group(1);
			}
		}
		return transName;
		/*Pattern afterPattern = Pattern.compile("(\\d+)(B|#|T|号变|L联变|主变)");
		Pattern beforePattern = Pattern.compile("#(\\d+)");
		Matcher afterMatcher = afterPattern.matcher(transName);
		if(afterMatcher.find()){
			return afterMatcher.group(1);
		}else{
			Matcher beforeMatcher = beforePattern.matcher(transName);
			if(beforeMatcher.find()){
				return beforeMatcher.group(1);
			}else{
				return transName;
			}			
		}*/
	}
	
	
	/**
	 * <p>Description:从名称中提取线路名称</p>
	 * @author zjx
	 * @date 2017年6月30日
	 * @param lineName
	 * @return
	 */
	public static String getLineNameOfNw(String lineName){
		if(lineName.indexOf("断路器")!=-1){
			return lineName;
		}
		lineName = lineName.replaceAll("\\d+(kV|kv)", "");
		lineName = lineName.replaceAll("短引线", "");
		Pattern pattern = Pattern.compile("(\\S+)(?=(线|路|回))");
		Matcher matcher = pattern.matcher(lineName);
		if(matcher.find()){
			return matcher.group(1);
		}else{
			return lineName;
		}
	}
	
	/**
	 * <p>Description:从名称中提取线路名称</p>
	 * @author zjx
	 * @date 2017年6月30日
	 * @param lineName
	 * @return
	 */
	public static String getLineNameOfNw2(String lineName){
		int pos = lineName.indexOf("回线");
		if(pos > -1){
			lineName =  lineName.substring(0, pos+1);
		} else {
			pos = lineName.indexOf("线");
			if(pos > -1){
				lineName =  lineName.substring(0, pos+1);
			} else {
				 pos = lineName.indexOf("回");
				 if(pos > -1){
					 lineName = lineName.substring(0,  pos+1);
				 } 
			}
		}
		if(pos > -1)
			lineName = convertString(lineName,line_regex);
		return lineName;
	}
	/**
	 * 线路名称的匹配
	 * @param ln1
	 * @param ln2
	 * @return
	 */
	public static boolean lineNameMatching(String ln1,String ln2){
		String tmpl1 = convertString(ln1,line_regex);
		String tmpl2 = convertString(ln2,line_regex);
		if(tmpl1.contains(tmpl2) || tmpl2.contains(tmpl1)){
			return true;
		} else {
			
			int len1 = tmpl1.length();
			int len2 = tmpl2.length();
			int mlen = stringMatching(tmpl1,tmpl2);
			if(mlen >= len1 || mlen >= len2 ){
				return true;
			}
		}
		return false;
	}
	/**
	 * 简单的匹配
	 * @param s1
	 * @param s2
	 * @return
	 */
	public static int  stringMatching(String s1,String s2) {
		
		String[] s1array = new String[s1.length()];
		for (int i = 0; i < s1array.length; i++) {
			s1array[i] = s1.substring(i, i+1);
		}
		
		String[] s2array = new String[s2.length()];
		for (int i = 0; i < s2array.length; i++) {
			s2array[i] = s2.substring(i, i+1);
		}
		int count = 0;
		Map<String,Integer> matched = new HashMap<String,Integer>();
		for(String str1 : s1array){
			Integer preIndex = matched.get(str1);
			if(preIndex == null ){
				preIndex = -1;
			} 
			int i = s2.indexOf(str1,preIndex+1);
			if(i > -1){
				count++;
				matched.put(str1,i);
			}
		}
		return count;
	}
	public static String convertString(String sourceStr, String[][] source_regex){
		String rtn = sourceStr;
		for( String[] et : source_regex){
			rtn = rtn.replaceAll(et[0],et[1]);
		}
		return rtn;
	}
	public static String[][] line_regex = new String[][]{
		{"\\s*", ""},
		{"//|[0-9]+$", ""},
		{"//|[0-9]+[-,_]", ""},
		{"//|[0-9]+kV", ""},
		{"//|回$", "线"},
		{"//|丁|IV|iv|Ⅳ|4", "四"},
		{"//|丙|III|iii|Ⅲ|3", "三"},
		{"//|乙|II|ii|Ⅱ|2", "二"},
		{"//|甲|I|i|Ⅰ|1", "一"},
	};
	/**
	 * <p>Description:比对线路名是否相等，比对策略首字相等，剩余字一方包含另一方</p>
	 * @author zjx
	 * @date 2017年6月27日
	 * @param lineName1
	 * @param lineName2
	 * @return
	 */
	public static boolean isLineNameEquals(String lineName1,String lineName2){
//		String staLineName1 = toRomanNum(getLineNameOfNw2(lineName1));
//		String staLineName2 = toRomanNum(getLineNameOfNw2(lineName2));
		String staLineName1 = getLineNameOfNw2(lineName1);
		String staLineName2 = getLineNameOfNw2(lineName2);
//		log.info(staLineName1+"---"+staLineName2);
		return lineNameMatching(staLineName1, staLineName2);
//		if(staLineName1.equals(staLineName2)){
//			return true;
//		}
//		//进行包含比较，必须两个名字汉字数目大于等于2
//		if(staLineName1.length()<2||staLineName2.length()<2){
//			return false;
//		}
//		
//		//名字逆序
//		if(staLineName1.length()==staLineName2.length()){
//			boolean reversedEquals = true;
//			for(int i=0;i<staLineName1.length();i++){
//				if(!staLineName1.subSequence(i, i+1).equals(staLineName2.subSequence(staLineName1.length()-i-1, staLineName1.length()-i))){
//					reversedEquals = false;
//				}
//			}
//			if(reversedEquals){
//				return true;
//			}
//		}
//		//首字母相等，一方包含另一方
//		if(staLineName1.length()>=1&&staLineName2.length()>=1){//首字比较
//			if(!staLineName1.substring(0, 1).equals(staLineName2.substring(0, 1))){
//				return false;
//			}
//		}
//		String longLineName;
//		String shortLineName;
//		if(staLineName1.length()>staLineName2.length()){
//			longLineName = staLineName1;
//			shortLineName = staLineName2;
//		}else if(staLineName1.length()<staLineName2.length()){
//			longLineName = staLineName2;
//			shortLineName = staLineName1;
//		}else{
//			return false;
//		}
//		
//		for(int i=1;i<shortLineName.length();i++){
//			if(longLineName.indexOf(shortLineName.substring(i, i+1))==-1){
//				return false;
//			}
//		}
//		return true;
	}
	
	/**
	 * <p>Description:变压器  保护与开关量名称  是否是同一套保护 ,前提条件是 变压器名称一致，其次保护类型一致或者 从保护名称提取的为 第三套保护而从开关量中提取的为非电量保护</p>
	 * @author zjx
	 * @date 2017年6月29日
	 * @param protectionName
	 * @param statusChannelName
	 * @return
	 */
	public static boolean isTransformerProtectionEquals(String protectionName,String statusChannelName){
		if(NameTool.getTransformerNameOfNw(protectionName).equals(NameTool.getTransformerNameOfNw(statusChannelName))){
			String typeOfProtectioName = ProtectionNwUtil.getProtectionType(protectionName);
			String typeOfStatusChannel = ProtectionNwUtil.getProtectionType(statusChannelName);
			if(typeOfProtectioName.equals(typeOfStatusChannel)){
				return true;
			}
			
		}
		return false;

	}
	
	/**
	 * <p>Description:电抗器  保护与开关量名称  是否是同一套保护</p>
	 * @author zjx
	 * @date 2017年6月29日
	 * @param protectionName
	 * @param statusChannelName
	 * @return
	 */
	public static boolean isReactorProtectionEquals(String protectionName,String statusChannelName,String deviceOneName){
		if(isLineNameEquals(protectionName, statusChannelName)
				&&!statusChannelName.equals(NameTool.getReactorNameOfNw(statusChannelName))
				&&ProtectionNwUtil.getProtectionType(protectionName).equals(ProtectionNwUtil.getProtectionType(statusChannelName))){
			return true;
		}else{
			return false;
		}	
	}
	
	
	/**
	 * <p>Description:线路    保护 与开关量名称 是否是同一套保护</p>
	 * @author zjx
	 * @date 2017年6月29日
	 * @param protectionName
	 * @param statusChannelName
	 * @return
	 */
	public static boolean isLineProtectionEquals(String protectionName,String statusChannelName){
		String dbPtype = ProtectionNwUtil.getProtectionType(protectionName);
		String cfgPtype = ProtectionNwUtil.getProtectionType(statusChannelName);
		String dbLineName = getLineNameOfNw2(protectionName);
		String cfgLineName = getLineNameOfNw2(statusChannelName);
//		log.info(dbLineName+"---"+cfgLineName);
		boolean le = lineNameMatching(dbLineName, cfgLineName);
		boolean te = dbPtype.equals(cfgPtype);
		return le&&te;
//		if(NameTool.isLineNameEquals(protectionName,statusChannelName)
//				&& dbPtype.equals(cfgPtype)){
//			return true;
//		}else{
//			return false;
//		}	
	}
	
	
	
	/**
	 * <p>Description:母线    保护 与开关量名称 是否是同一套保护</p>
	 * @author zjx
	 * @date 2017年6月29日
	 * @param protectionName
	 * @param statusChannelName
	 * @return
	 */
	public static boolean isBusProtectionEquals(String protectionName,String statusChannelName){
		if(NameTool.getBusNameOfNw(protectionName).equals(NameTool.getBusNameOfNw(statusChannelName))
				&&(ProtectionNwUtil.getProtectionType(protectionName).equals(ProtectionNwUtil.getProtectionType(statusChannelName))
						)){
			return true;
		}else{
			return false;
		}
	}
	
	
	/**
	 * <p>Description:判断是否是开关保护名称</p>
	 * @author zjx
	 * @date 2017年6月30日
	 * @param statusChannelName
	 * @param deviceOneName
	 * @return
	 */
	public static boolean isBreakerProtectionEquals(String statusChannelName,String deviceOneName){
		log.info(statusChannelName+"---"+deviceOneName);
		if(statusChannelName.indexOf(deviceOneName)!=-1){
			return true;
		}else{
			return false;
		}
	}
	
	/**
	 * <p>Description:判断是否是短引线保护名称</p>
	 * @author zjx
	 * @date 2017年6月30日
	 * @param statusChannelName
	 * @param protectionName
	 * @return
	 */
	public static boolean  isStubProtecationEquals(String statusChannelName,String protectionName){
		if(statusChannelName.indexOf("短引线")!=-1&&protectionName.indexOf("短引线")!=-1){
			if(ProtectionNwUtil.getProtectionType(protectionName).equals(ProtectionNwUtil.getProtectionType(statusChannelName))){
				if(isLineNameEquals(protectionName, statusChannelName)){
					return true;
				}else if(getTransformerNameOfNw(statusChannelName).equals(getTransformerNameOfNw(protectionName))){
					return true;
				}else if(getBusNameOfNw(statusChannelName).equals(getBusNameOfNw(protectionName))){
					return true;
				}else if(getBreakerNameOfNw(statusChannelName).equals(getBreakerNameOfNw(protectionName))){
					return true;
				}
			}
		}
		return false;
	}
	
	
	/**
	 * <p>Description: 判断保护名称是否相等</p>
	 * @author zjx
	 * @date 2017年6月29日
	 * @param protectionType
	 * @param protectionName
	 * @param deviceOneName
	 * @param statusChannelName
	 * @return
	 */
	public static boolean isProtectionEquals(String protectionType,String protectionName,String deviceOneName,String statusChannelName){
		boolean isEquals = false;
		if(statusChannelName.indexOf("短引线")!=-1||protectionName.indexOf("短引线")!=-1){
			return isStubProtecationEquals(statusChannelName, protectionName);
		}else if(protectionType.indexOf(IProtectionNw.REACTOR_PROTECTION)!=-1){
			return isReactorProtectionEquals(protectionName, statusChannelName,deviceOneName);
		}else if(protectionType.indexOf(IProtectionNw.BUS_PROTECTION)!=-1){
			return isBusProtectionEquals(protectionName, statusChannelName);
		}else if(protectionType.indexOf(IProtectionNw.TRANSFORMER_PROTECTION)!=-1){
			return isTransformerProtectionEquals(protectionName, statusChannelName);
		}else if(protectionType.indexOf(IProtectionNw.LINE_PROTECTION)!=-1){
			return isLineProtectionEquals(protectionName, statusChannelName);
		}else if(protectionType.indexOf(IProtectionNw.BREAKER_PROTECTION)!=-1){
			return isBreakerProtectionEquals(statusChannelName, deviceOneName);
		}
		return isEquals;
	}

	
	/**
	 * <p>Description:检查  是否是有效的通道名称， 例如 通道11，开关量11，模拟量11，备用，30-30#开关量通道均不是</p>
	 * @author zjx
	 * @date 2017年6月30日
	 * @param name
	 * @return
	 */
	public static boolean isEffectiveChannelName(String name){
		String matchRegexes[] = {"(备用|(开关|通道|开关量|模拟量|线路|单量) {0,}\\d+)","开关量通道","^\\w$","^\\w(\\w| |-|_)*\\w$"};
		return !isMatch(name, matchRegexes);
	}
	
	

	
	/**
	 * <p>Description: 查看字符串是否符合正则表达式条件，不匹配则返回 "",匹配则返回匹配的捕获组的 第二个分组</p>
	 * @author zjx
	 * @date 2017年6月30日
	 * @param matchRegexes
	 * @param noMatchRegexes
	 * @param name
	 * @return
	 */
	public static String matchString(String matchRegexes[],String noMatchRegexes[],String name){
		if(noMatchRegexes!=null){
			for(int i=0;i<noMatchRegexes.length;i++){
				Pattern pattern = Pattern.compile(noMatchRegexes[i]);
				Matcher matcher = pattern.matcher(name);
				if(matcher.find()){
					return "";
				}
			}
		}
		
		if(matchRegexes!=null){
			for(int i=0;i<matchRegexes.length;i++){
				Pattern pattern = Pattern.compile(matchRegexes[i]);
				Matcher matcher = pattern.matcher(name);
				if(matcher.find()){
					return matcher.group(1);
				}
			}
		}
		return "";
	}
}

